package com.demo.java.OD551_600.OD579;

import java.io.*;

/**
 * @author bug菌
 * @Source 公众号：猿圈奇妙屋
 * @des： 【没有回文串(B卷-100分)】问题
 * @url： https://blog.csdn.net/weixin_43970743/article/details/146566736
 */
public class OdMain {
    public static void main(String[] args) throws IOException {
        new OdMain().start();  // 启动主函数
    }

    public void start() throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s = br.readLine();  // 读取字典序的大小限制
        while (s != null) {
            int maxCharNum = Integer.parseInt(s);  // 最大字符的数量，字母限制为 a-z
            String startStr = br.readLine().toLowerCase();  // 读取并转为小写的初始字符串
            char maxChar = (char) ('a' + maxCharNum - 1);  // 最大字符
            String maxStr = getMaxStr(maxCharNum, startStr.length());  // 获取最大字符组成的字符串
            String str = addOne(startStr, maxChar);  // 增加字典序
            boolean has = false;  // 标记是否找到符合条件的字符串
            while (compare(maxStr, str)) {
                if (!checkHuiWenTotal(str)) {  // 检查该字符串是否含有回文子串
                    System.out.println(str);  // 输出符合条件的字符串
                    has = true;
                    break;
                }
                str = addOne(str, maxChar);  // 否则继续增加字典序
            }
            if (!has) {
                System.out.println("NO");  // 如果没有找到符合条件的字符串，输出 NO
            }
            s = br.readLine();  // 读取下一行输入
        }
    }

    // 增加字典序
    public String addOne(String s, char maxChar) {
        boolean upOne = true;
        StringBuilder sb = new StringBuilder(s.length());
        for (int i = s.length() - 1; i >= 0; i--) {
            char c = s.charAt(i);
            if (upOne) {
                upOne = false;
                c = (char) (c + 1);  // 增加当前字符
                if (c > maxChar) {
                    c = 'a';  // 如果超过最大字符，则重置为 'a'
                    upOne = true;
                }
            }
            sb.append(c);  // 逐步构建新字符串
        }
        if (upOne) {
            sb.append('a');  // 如果最后需要增加字符，则添加 'a'
        }
        return sb.reverse().toString();  // 返回反转后的字符串
    }

    // 检查是否有回文子串
    public boolean checkHuiWenTotal(String s) {
        int maxLength = s.length();
        int minLength = 2;  // 最小回文长度为 2
        int nowLength = maxLength;
        while (nowLength >= minLength) {
            for (int i = 0; i <= s.length() - nowLength; i++) {
                if (checkHuiWen(s.substring(i, i + nowLength))) {
                    return true;  // 如果发现回文子串，则返回 true
                }
            }
            nowLength--;  // 逐步缩小回文子串的长度
        }
        return false;  // 没有回文子串
    }

    // 检查是否是回文
    public boolean checkHuiWen(String s) {
        int i = 0;
        int j = s.length() - 1;
        char[] charArray = s.toCharArray();
        while (i <= j) {
            if (charArray[i++] != charArray[j--]) {
                return false;  // 如果有不同字符，返回 false
            }
        }
        return true;  // 如果完全相等，则是回文
    }

    // 获取最大字符组成的字符串
    public String getMaxStr(int maxCharNum, int length) {
        char maxChar = (char) ('a' + maxCharNum - 1);  // 获取最大字符
        StringBuilder sb = new StringBuilder(length);
        for (int i = 0; i < length; i++) {
            sb.append(maxChar);  // 构建由最大字符组成的字符串
        }
        return sb.toString();  // 返回该字符串
    }

    // 比较两个字符串的字典序
    public boolean compare(String s1, String s2) {
        if (s1.length() > s2.length()) {
            return true;  // 如果 s1 长度大，则字典序较小
        }
        if (s1.length() < s2.length()) {
            return false;  // 如果 s1 长度小，则字典序较大
        }
        for (int i = 0; i < s1.length(); i++) {
            if (s1.charAt(i) > s2.charAt(i)) {
                return true;  // 字典序较小
            }
            if (s1.charAt(i) < s2.charAt(i)) {
                return false;  // 字典序较大
            }
        }
        return false;  // 字典序相同
    }
}